import java.util.Arrays;

class Students {
    //成员变量
    public String name;
    public String sex;
    public int age;

    //方法
    public void doClass(){
        System.out.println("学java!");
    }
}
class WashMachine{
    public String brand;
    public String color;
    public double weight;

    public void washClothes(){
        System.out.println("洗衣服！");
    }
    public void dryClothes(){
        System.out.println("脱水！");
    }
}

public class j3_30 {
    public static void main(String[] args) {
        WashMachine washMachine1=new WashMachine();//new一个实例化对象washMachine1
        washMachine1.brand="海尔";//利用.访问对象中的成员变量
        washMachine1.dryClothes();//利用.调用类方法
        System.out.println(washMachine1.brand);
        System.out.println("_________");
        WashMachine washMachine2=new WashMachine();//可以new多个实例化对象
        washMachine2.brand="美的";
        System.out.println(washMachine2.brand);
        washMachine2.dryClothes();
    }

    //判断一个数组中是否存在连续3个奇数
    public static boolean fun8(int[]array){
        int count=0;
        for (int i = 0; i < array.length; i++) {
            if(array[i]%2!=0){
                count++;
                if(count==3){
                    return true;
                }
            }
            else{
                count=0;
            }
        }
        return false;
    }

    public static void main9(String[] args) {
        int[]array={1,2,3,0,7,9,6};
        System.out.println(fun8(array));
    }

    //在数组{2，7，11，15}中找两个数相加的值为13，返回【2，11】
    public static int[]fun4(int[]array,int target){
        int[]ret={-1,-1};//没找到就直接返回-1
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array.length; j++) {
                if(array[i]+array[j]==target){
                    ret[0]=array[i];
                    ret[1]=array[j];
                }
            }
        }
        return ret;
    }

    public static void main8(String[] args) {
        int[]array={2,7,11,15};
        int[]ret=fun4(array,4);
        System.out.println(Arrays.toString(ret));
    }

    //将数组中奇数放在前面，偶数放在后面
    public static void fun3(int[] array) {
        int left = 0;
        int right = array.length - 1;
        while (left < right) {
            while (left < right && array[left] % 2 != 0) {//left<right防止越界
                //奇数
                left++;
            }
            while (left < right && array[right] % 2 == 0) {//left<right防止越界
                //偶数
                right--;
            }
            int tmp = array[left];
            array[left] = array[right];
            array[right] = tmp;
        }
    }

    public static void main77(String[] args){
            int[] array = {1, 2, 3, 5, 6, 7};
            fun3(array);
            System.out.println(Arrays.toString(array));
        }

    public static void main222(String[] args) {
        //二维数组
        int[][]array={{1,3,4,5},{6,6,4,7}};
        int[][]array2=new int[][]{{1,3,4,5},{6,6,4,7}};
        int[][]array3=new int[2][4];//全部初始化为0
        for (int i = 0; i < 2; i++) {
            for (int j = 0; j < 4; j++) {
                System.out.print(array[i][j]+" ");
            }
            System.out.println();
        }
        System.out.println("#########");
        //另一种不用数二维数组的个数的方法
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.print(array[i][j]+" ");
            }
            System.out.println();
        }
    }
    public static void main6(String[] args) {
        int[]array={9,8,7,6,5,4,3,2};
        BubbleSort(array);
        reverse(array);
        int[]copy=copy1(array);
        System.out.println(Arrays.toString(copy));

        //Java里自带的拷贝
        /**
         * 可以看作是扩容
         */


        int[] cp=Arrays.copyOf(array,array.length*2);
        System.out.println(Arrays.toString(cp));

        //数组填充  可以局部填充
        int[] array4=new int[10];
        Arrays.fill(array4,1,6,666);//在数组array4中的【1，6）的位置填充666
        System.out.println(Arrays.toString(array4));
    }
    //数组的拷贝
    public static int[] copy1(int[]array){
        int[]tmp=new int[array.length];
        for (int i = 0; i < array.length; i++) {
            tmp[i]=array[i];
        }
        return tmp;
    }

    //数组的逆置
    public static void reverse(int[]array){
        int left=0;
        int right= array.length-1;
        while(left<right){
            int tmp=array[left];
            array[left]=array[right];
            array[right]=tmp;
            left++;
            right--;
        }
    }

    //java实现冒泡排序
    public static void BubbleSort(int[]array){
        boolean flag=true;
        for (int i = 0; i < array.length-1; i++) {
            //第一趟
            for (int j = 0; j < array.length-1-i; j++) {//减i表示每一趟都比上一趟少一次
                if(array[j]>array[j+1]){
                    int tmp=array[j];
                    array[j]=array[j+1];
                    array[j+1]=tmp;
                    flag=false;
                }
            }
            if(flag==true){
                break;
            }
        }
    }

    //查找数组中的元素  顺序查找
    public static int checkNum(int[]array,int key){
        for (int i = 0; i < array.length; i++) {
            if(array[i]==key){
                return i;
            }
        }
        return -1;
    }
    //二分查找  建立在当前数组是有序的
    public static int zheBanFind(int[]array,int key){
        int right=0;
        int left= array.length-1;
        while(right<=left){
            //int mid=(right+left)/2;
            //int mid=(left+(left-righ)/2);//防止越界
            int mid=(right+left)>>>1;//右移一位，相当于除法
            if(array[mid]<key){
                right=mid+1;
            }
            if(array[mid]>key){
                left=mid-1;
            }
            if(array[mid]==key){
                return mid;
            }
        }
        return -1;
    }

    public static void main4(String[] args) {
        int[]array={1,2,3,6,85};
        //int index=checkNum(array,85);

        //数组排序  将数组快速排成有序的
        Arrays.sort(array,1,4);//可以实现局部排序下标[1,4)

        //Java自带的二分查找
        int findN=Arrays.binarySearch(array,3);
        int index=zheBanFind(array,85);
        System.out.println(index);
    }

    //实现自己的数组转成字符串
    public static String myToString(int[] array){
        //判断空指针情况 （没有指向对象）
        if(array==null){
            return null;
        }
        //判断空数组情况  （指向的对象为空）
        if(array.length==0){
            return "[]";
        }

        String ret="[";
        for (int i = 0; i < array.length; i++) {
            ret=ret+array[i];
            if(i!= array.length-1){
                ret=ret+" ,";//字符串拼接
            }
        }
        ret+="]";
        return ret;
    }

    public static void main3(String[] args) {
        int[] array={1,2,4,5};
        String ret=myToString(array);//本质上还是传值调用
        System.out.println(ret);
    }
    //无返回值
    public static void func(int[]array1){
        for (int i = 0; i < array1.length; i++) {
            array1[i]= array1[i]*2;//将每个数字扩大2倍
        }
    }
    //数组作为返回值
    public static int[] func2(int[]array1){
        int[]tmp=new int[array1.length];
        for (int i = 0; i < array1.length; i++) {
            tmp[i]=array1[i]*3;
        }
        return tmp;//Java中数组可以是返回值
    }

    public static void main2(String[] args) {
        int[] array={1,2,4,5};
        int[] retArray=func2(array);//本质上还是传值调用
        String ret=Arrays.toString(retArray);
        System.out.println(ret);
    }

        public static void main1(String[] args) {
            int[] array={1,2,3,4,5};
            int []arr1=new int[]{1,3,4};
            int []aa=new int[19];
            System.out.println(array.length);//求数组长度
            System.out.println(array[2]);//通过下标访问数组元素

            //程序报错会报最前面的

            //遍历数组
            for (int i = 0; i < array.length; i++) {
                System.out.print(array[i]+" ");
            }
            //for each循环 遍历数组，把每一个值放入x中,获取不到下标
            for (int x:array) {
                System.out.print(x+" ");
            }
            //借助Java的原生的方法    查看源码 ctrl+鼠标左键
            String ret= Arrays.toString(array);//将数组元素以字符串的形式输出
            System.out.println(ret);
        }

    public static void main0(String[] args) {
        int[] array={1,2,3,4,5};
        String ret= Arrays.toString(array);//将数组元素以字符串的形式输出
        System.out.println(ret);
    }
}
